package com.hera.process.config.rest.controller;

import java.io.IOException;
import java.util.Map;

import org.apache.log4j.Logger;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.hera.base.domain.MensajeJSON;
import com.hera.base.rest.controller.BaseController;
import com.hera.base.util.Constantes;
import com.hera.base.util.FiltroDTO;
import com.hera.process.config.service.ProcInstancNoteService;
import com.hera.process.config.service.ProcInstanceHistoryService;
import com.hera.process.config.service.ProcessCategoryService;
import com.hera.process.config.service.ProcessGroupService;
import com.hera.process.config.service.ProcessGroupUserService;
import com.hera.process.config.service.ProcessInstanceService;
import com.hera.process.config.service.ProcessService;
import com.hera.process.config.service.ProcessSupervisroService;
import com.hera.process.config.service.StageRollupService;
import com.hera.process.config.service.StageService;
import com.hera.process.config.service.StageUserService;
import com.hera.process.config.service.SwimlaneService;
import com.hera.process.config.service.TaskInstanceCacheService;
import com.hera.process.config.service.TaskUserService;
import com.hera.process.workflow.domain.ProcInstancHistory;
import com.hera.process.workflow.domain.ProcInstancNote;
import com.hera.process.workflow.domain.Process;
import com.hera.process.workflow.domain.ProcessCategory;
import com.hera.process.workflow.domain.ProcessGroup;
import com.hera.process.workflow.domain.ProcessGroupUser;
import com.hera.process.workflow.domain.ProcessInstance;
import com.hera.process.workflow.domain.ProcessSupervisor;
import com.hera.process.workflow.domain.Stage;
import com.hera.process.workflow.domain.StageRollup;
import com.hera.process.workflow.domain.StageUser;
import com.hera.process.workflow.domain.Swimlane;
import com.hera.process.workflow.domain.TaskInstanceCache;
import com.hera.process.workflow.domain.TaskUser;

@Controller
@RequestMapping("workflow")
public class WorkflowController extends BaseController {

	static final Logger logger = Logger.getLogger(WorkflowController.class);
	
	

	@Autowired
	private ProcessGroupService processgroupService;

	@Autowired
	private ProcInstanceHistoryService procinstancehistorysService;
	
	@Autowired
	private ProcInstancNoteService procinstancnoteservice;
	
	@Autowired
	private ProcessService processservice;
	
	@Autowired
	private ProcessCategoryService processcategoryservice;
	
	@Autowired
	private ProcessGroupUserService processgroupuserservice;
	
	@Autowired
	private ProcessInstanceService processinstanceservice;
	
	@Autowired
	private ProcessSupervisroService processsupervisorservice;
	
	@Autowired
	private StageService	stageservice;
	
	@Autowired
	private	StageRollupService	stagerollupservice;
	
	@Autowired
	private StageUserService stageuserservice;
	
	@Autowired
	private SwimlaneService swimlaneservice;
	
	@Autowired
	private TaskInstanceCacheService Taskinstancecacheservice;
	
	@Autowired
	private TaskUserService taskuserservice;
	
	
	

	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESSGROUP SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	@RequestMapping(value = "processgroup/list", method = RequestMethod.POST)
    @ResponseBody
    public MensajeJSON listProcessGroup(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listProcessGroup  " + filtroDTO.toString());
		return obtenerMensajeJSON(processgroupService.findAll(filtroDTO));
		
    }
	/*
	@RequestMapping(value = "parameter/list", method = RequestMethod.GET)
    @ResponseBody
    public List<Parameter> listParametersGet() {
		logger.info("listParameters");		
        return parameterService.findAll();
    }*/
	
	@RequestMapping(value = "processgroup/save", method = RequestMethod.POST)
    @ResponseBody
    public MensajeJSON saveProcessGroup(@RequestBody ProcessGroup processgroup) {
		logger.info("grabando el parametro....");
		processgroupService.save(processgroup);
		return obtenerMensajeJSON(processgroup);		
    }
	
	@RequestMapping(value = "processgroup/update", method = RequestMethod.POST)
    @ResponseBody
    public MensajeJSON updateProcessGroup(@RequestBody ProcessGroup processgroup) {
		logger.info("grabando el parametro....");
		processgroupService.update(processgroup);
		return obtenerMensajeJSON(processgroup);		
    }
	
	@RequestMapping(value = "processgroup/delete", method = RequestMethod.POST)
    @ResponseBody
    public MensajeJSON deleteProcessGroup(@RequestBody ProcessGroup processgroup) {
		logger.info("grabando el parametro....");
		processgroupService.delete(processgroup);
		return obtenerMensajeJSON(processgroup);		
    }
	
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCINSTANCEHISTORY SERVICE //////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */

	
	@RequestMapping(value = "procInstanchistory/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcInstancHistories(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listDataSource  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(procinstancehistorysService.findAll(filtroDTO));
   }
	
	@RequestMapping(value = "procInstanchistory/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcInstancHistory(@RequestBody ProcInstancHistory procinstanchistory) {
		logger.info("grabando el parametro....");
		procinstancehistorysService.save(procinstanchistory);
		return obtenerMensajeJSON(procinstanchistory);		
   }
	
	@RequestMapping(value = "procInstanchistory/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcInstancHistory(@RequestBody ProcInstancHistory procinstanchistory) {
		logger.info("grabando el parametro....");
		procinstancehistorysService.update(procinstanchistory);
		return obtenerMensajeJSON(procinstanchistory);		
   }
	
	@RequestMapping(value = "procInstanchistory/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcInstancHistory(@RequestBody ProcInstancHistory procinstanchistory) {
		logger.info("grabando el parametro....");
		procinstancehistorysService.delete(procinstanchistory);
		return obtenerMensajeJSON(procinstanchistory);		
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCINSTANCENOTE SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "procintancenote/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcInstancNotes(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listDataSource  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(procinstancnoteservice.findAll(filtroDTO));
   }
	
	
	@RequestMapping(value = "procintancenote/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcInstancNote(@RequestBody ProcInstancNote procinstancnote) {
		logger.info("grabando el parametro....");
		procinstancnoteservice.save(procinstancnote);
		return obtenerMensajeJSON(procinstancnote);		
   }
	
	@RequestMapping(value = "procintancenote/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcInstancNote(@RequestBody ProcInstancNote procinstancnote) {
		logger.info("grabando el parametro....");
		procinstancnoteservice.update(procinstancnote);
		return obtenerMensajeJSON(procinstancnote);
   }
	
	@RequestMapping(value = "procintancenote/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcInstancNote(@RequestBody ProcInstancNote procinstancnote) {
		logger.info("grabando el parametro....");
		procinstancnoteservice.delete(procinstancnote);
		return obtenerMensajeJSON(procinstancnote);		
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESS SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "process/list", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON listProcesses(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listDataSource  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(processservice.findAll(filtroDTO));
	}
	
	@RequestMapping(value = "process/save", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON saveProcess(@RequestBody Process process) {
		logger.info("grabando el parametro....");
		processservice.save(process);
		return obtenerMensajeJSON(process);		
	}
	
	@RequestMapping(value = "process/update", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON updateProcess(@RequestBody Process process) {
		logger.info("grabando el parametro....");
		processservice.update(process);
		return obtenerMensajeJSON(process);
	}
	
	@RequestMapping(value = "process/delete", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON deleteProcess(@RequestBody Process process) {
		logger.info("grabando el parametro....");
		processservice.delete(process);
		return obtenerMensajeJSON(process);		
	}
	@RequestMapping(value = "process/publicarProceso", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON publicarProceso(@RequestBody Process process) {
		logger.info("grabando el parametro....");
		processservice.publicarProceso(process);
		return obtenerMensajeJSON(process);		
	}
	
	@RequestMapping(value = "process/findAllFormFieldInProcess", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON findAllFormFieldInProcess(@RequestBody Process process) {
		logger.info("grabando el parametro....");
		return obtenerMensajeJSON(processservice.findAllFormFieldInProcess(process));				
	}
	
	@RequestMapping(value = "process/validarProceso", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON validarProceso(@RequestBody Process process) {
		logger.info("validarProceso ");
		return obtenerMensajeJSON(processservice.validarProceso(process));		
	}
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESSCATEGGORY SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "processcategory/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcessCategories(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listDataSource  " + filtroDTO.toString());
		return obtenerMensajeJSON(processcategoryservice.findAll(filtroDTO));
   }
	
	////error
	
	
	@RequestMapping(value = "processcategory/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcessCategory(@RequestBody ProcessCategory processcategory) {
		logger.info("grabando el parametro....");
		processcategoryservice.save(processcategory);
		return obtenerMensajeJSON(processcategory);		
   }
	
	@RequestMapping(value = "processcategory/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcessCategory(@RequestBody ProcessCategory processcategory) {
		logger.info("grabando el parametro....");
		processcategoryservice.update(processcategory);
		return obtenerMensajeJSON(processcategory);
   }
	
	@RequestMapping(value = "processcategory/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcessCategory(@RequestBody ProcessCategory processcategory) {
		logger.info("grabando el parametro....");
		processcategoryservice.delete(processcategory);
		return obtenerMensajeJSON(processcategory);		
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESSGROUPUSER SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "processgroupuser/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcessGroupUsers(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listProcessGroupUsers  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(processgroupuserservice.findAll(filtroDTO));
   }
	
	//dsffffd
	@RequestMapping(value = "processgroupuser/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcessGroupUser(@RequestBody ProcessGroupUser processgroupuser) {
		logger.info("grabando el parametro....");
		processgroupuserservice.save(processgroupuser);
		return obtenerMensajeJSON(processgroupuser);		
   }
	
	@RequestMapping(value = "processgroupuser/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcessGroupUser(@RequestBody ProcessGroupUser processgroupuser) {
		logger.info("grabando el parametro....");
		processgroupuserservice.update(processgroupuser);
		return obtenerMensajeJSON(processgroupuser);
   }
	
	@RequestMapping(value = "processgroupuser/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcessGroupUser(@RequestBody ProcessGroupUser processgroupuser) {
		logger.info("grabando el parametro....");
		processgroupuserservice.delete(processgroupuser);
		return obtenerMensajeJSON(processgroupuser);		
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESSINSTANCE SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "processinstance/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcessInstances(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listProcessGroupUsers  " + filtroDTO.toString());
		
		//return processinstanceservice.findAll(filtroDTO);
		return obtenerMensajeJSON(processinstanceservice.findAll(filtroDTO));
   }
	//////fvgfg
	@RequestMapping(value = "processinstance/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcessInstance(@RequestBody ProcessInstance proinstance) {
		logger.info("grabando el parametro....");
		processinstanceservice.save(proinstance);
		return obtenerMensajeJSON(proinstance);		
   }
	
	@RequestMapping(value = "processinstance/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcessInstance(@RequestBody ProcessInstance proinstance) {
		logger.info("grabando el parametro....");
		processinstanceservice.update(proinstance);
		return obtenerMensajeJSON(proinstance);
   }
	
	@RequestMapping(value = "processinstance/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcessInstance(@RequestBody ProcessInstance proinstance) {
		logger.info("grabando el parametro....");
		processinstanceservice.delete(proinstance);
		return obtenerMensajeJSON(proinstance);		
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// PROCESSSUPERVISOR SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "processsupervisor/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listProcessSupervisors(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listProcessGroupUsers  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(processsupervisorservice.findAll(filtroDTO));
   }
	//cgfgfgfgfgfg
	@RequestMapping(value = "processsupervisor/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveProcessSupervisor(@RequestBody ProcessSupervisor prosuperv) {
		logger.info("grabando el parametro....");
		processsupervisorservice.save(prosuperv);
		return obtenerMensajeJSON(prosuperv);		
   }
	
	@RequestMapping(value = "processsupervisor/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateProcessSupervisor(@RequestBody ProcessSupervisor prosuperv) {
		logger.info("grabando el parametro....");
		processsupervisorservice.update(prosuperv);
		return obtenerMensajeJSON(prosuperv);
   }
	
	@RequestMapping(value = "processsupervisor/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteProcessSupervisor(@RequestBody ProcessSupervisor prosuperv) {
		logger.info("grabando el parametro....");
		processsupervisorservice.delete(prosuperv);
		return obtenerMensajeJSON(prosuperv);		
   }
	
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// STAGE SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "stage/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listStages(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listStages  " + filtroDTO.toString());
		return obtenerMensajeJSON(stageservice.findAll(filtroDTO));
		
   }
	
	@RequestMapping(value = "stage/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveStage(@RequestBody Stage stage) {
		logger.info("grabando el stage....");
		stageservice.save(stage);
		return obtenerMensajeJSON(stage);		
   }
	
	@RequestMapping(value = "stage/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateStage(@RequestBody Stage stage) {
		logger.info("actualizando el stage....");
		stageservice.update(stage);
		return obtenerMensajeJSON(stage);
   }
	
	@RequestMapping(value = "stage/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteStage(@RequestBody Stage stage) {
		logger.info("borrando el stage....");
		stageservice.delete(stage);
		return obtenerMensajeJSON(stage);
   }
	
	@RequestMapping(value = "stage/findStageByProcessId", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON findStageByProcessId(@RequestBody Stage stage) {
		logger.info("listando el stage por proceso");
		return obtenerMensajeJSON(stageservice.findStageByProcessId(stage.getSwimlane().getProcess().getIdProcess()));
   }
	
	@RequestMapping(value = "stage/findStageByProcessAndIdDiagram", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON findStageByProcessAndIdDiagram(@RequestBody Stage stage) {
		logger.info("listando el stage por proceso");
		return obtenerMensajeJSON(stageservice.findStageByProcessAndIdDiagram(stage.getSwimlane().getProcess().getIdProcess(), stage.getIdFigure()));
   }
	@RequestMapping(value = "stage/findStageByProcessIdandTypeId", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON findStageByProcessIdandTypeId(@RequestBody Stage stage) {
		logger.info("listando el stage por proceso y tipo ");
		return obtenerMensajeJSON(stageservice.findStageByProcessIdandTypeId(
				stage.getSwimlane().getProcess().getIdProcess(), stage
						.getSwimlane().getProcess().getIdType()));
	}
	
	@RequestMapping(value = "stage/createProcessInstance", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON createProcessInstance(@RequestBody Map<String, Object> entity) throws JsonGenerationException, JsonMappingException, IOException{
		
		logger.info("grabando el metadata....");
		Stage stage = null;
		if(entity.containsKey(Constantes.STRINGVALUES.STRSTAGE)){
			//System.out.println(entity.get("$$stage$$"));
			ObjectMapper mapper = new ObjectMapper();
			String strJSON = mapper.writeValueAsString(entity.get(Constantes.STRINGVALUES.STRSTAGE));
			stage = mapper.readValue(strJSON, Stage.class);
			//System.out.println(stage);
			entity.remove(Constantes.STRINGVALUES.STRSTAGE);
		}		
		return obtenerMensajeJSON(processinstanceservice.createProcessInstance(stage, entity));
	}
	
	@RequestMapping(value = "stage/updateProcessInstance", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON updateProcessInstance(@RequestBody Map<String, Object> entity) throws JsonGenerationException, JsonMappingException, IOException{
		
		logger.info("actualizando la metadata....");
		TaskInstanceCache taskInstanceCache = null;
		if(entity.containsKey(Constantes.STRINGVALUES.STRTASKINSTANCE)){
			ObjectMapper mapper = new ObjectMapper();
			String strJSON = mapper.writeValueAsString(entity.get(Constantes.STRINGVALUES.STRTASKINSTANCE));
			taskInstanceCache = mapper.readValue(strJSON, TaskInstanceCache.class);
			entity.remove(Constantes.STRINGVALUES.STRTASKINSTANCE);
		}		
		return obtenerMensajeJSON(processinstanceservice.udpateProcessInstance(taskInstanceCache, entity));
	}
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// STAGEROOLLUP SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "stagerollup/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listStageRollups(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listSecuences  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(stagerollupservice.findAll(filtroDTO));
   }
	
	@RequestMapping(value = "stagerollup/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveStageRollup(@RequestBody StageRollup stagerollup) {
		logger.info("grabando el parametro....");
		stagerollupservice.save(stagerollup);
		return obtenerMensajeJSON(stagerollup);		
   }
	
	@RequestMapping(value = "stagerollup/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateStageRollup(@RequestBody StageRollup stagerollup) {
		logger.info("grabando el parametro....");
		stagerollupservice.update(stagerollup);
		return obtenerMensajeJSON(stagerollup);
   }
	
	@RequestMapping(value = "stagerollup/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteStageRollup(@RequestBody StageRollup stagerollup) {
		logger.info("grabando el parametro....");
		stagerollupservice.delete(stagerollup);
		return obtenerMensajeJSON(stagerollup);		
   }
	
	@RequestMapping(value = "stagerollup/findStageRollupByProcessId", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON findStageRollupByProcessId(@RequestBody Long idProcess) {
		logger.info("listado el stage rollup por proceso");
		return obtenerMensajeJSON(stagerollupservice.findStageRollupByProcessId(idProcess));
   }
	
	@RequestMapping(value = "stagerollup/findStageRollupByProcessAndIdDiagram", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON findStageRollupByProcessAndIdDiagram(@RequestBody StageRollup stagerollup) {
		logger.info("listado el stage rollup por proceso");
		return obtenerMensajeJSON(stagerollupservice.findStageRollupByProcessAndIdDiagram(
				stagerollup.getIdProcess(), stagerollup.getIdFigure()));
   }
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// STAGEUSER SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "stageuser/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listStageUsers(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listSecuences  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(stageuserservice.findAll(filtroDTO));
   }
	
	@RequestMapping(value = "stageuser/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveStageUser(@RequestBody StageUser stageuser) {
		logger.info("grabando el parametro....");
		stageuserservice.save(stageuser);
		return obtenerMensajeJSON(stageuser);		
   }
	
	@RequestMapping(value = "stageuser/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateStageUser(@RequestBody StageUser stageuser) {
		logger.info("grabando el parametro....");
		stageuserservice.update(stageuser);
		return obtenerMensajeJSON(stageuser);
   }
	
	@RequestMapping(value = "stageuser/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteStageUser(@RequestBody StageUser stageuser) {
		logger.info("grabando el parametro....");
		stageuserservice.delete(stageuser);
		return obtenerMensajeJSON(stageuser);		
   }
	
	@RequestMapping(value = "stageuserbystage/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listStageUserByStage(@RequestBody Stage stage) {
		logger.info("listado por stage....");
		return obtenerMensajeJSON(stageuserservice.findByStageIdStage(stage.getIdStage()));
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// SWIMLANE SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "swimlane/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listSwimlanes(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listSecuences  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(swimlaneservice.findAll(filtroDTO));
   }
	
	@RequestMapping(value = "swimlane/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveSwimlane(@RequestBody Swimlane swimlane) {
		logger.info("grabando el parametro....");
		swimlaneservice.save(swimlane);
		return obtenerMensajeJSON(swimlane);		
   }
	
	@RequestMapping(value = "swimlane/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateSwimlane(@RequestBody Swimlane swimlane) {
		logger.info("grabando el parametro....");
		swimlaneservice.update(swimlane);
		return obtenerMensajeJSON(swimlane);
   }
	
	@RequestMapping(value = "swimlane/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteSwimlane(@RequestBody Swimlane swimlane) {
		logger.info("grabando el parametro....");
		swimlaneservice.delete(swimlane);
		return obtenerMensajeJSON(swimlane);		
   }
	
	@RequestMapping(value = "swimlane/findSwimlaneByProcessId", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON findSwimlaneByProcessId(@RequestBody Long idProcess) {
		logger.info("findSwimlaneByProcessId");
		
		return obtenerMensajeJSON(swimlaneservice.findSwimlaneByProcessId(idProcess));
   }
	
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// TaskInstanceCache SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */
	
	
	@RequestMapping(value = "taskintcache/list", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON listTaskInstanceCaches(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listSecuences  " + filtroDTO.toString());
		
		return obtenerMensajeJSON(Taskinstancecacheservice.findAll(filtroDTO));
   }
	
	@RequestMapping(value = "taskintcache/save", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON saveTaskInstanceCache(@RequestBody TaskInstanceCache taskincache) {
		logger.info("grabando el parametro....");
		Taskinstancecacheservice.save(taskincache);
		return obtenerMensajeJSON(taskincache);		
   }
	
	@RequestMapping(value = "taskintcache/update", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON updateTaskInstanceCache(@RequestBody TaskInstanceCache taskincache) {
		logger.info("grabando el parametro....");
		Taskinstancecacheservice.update(taskincache);
		return obtenerMensajeJSON(taskincache);
   }
	
	@RequestMapping(value = "taskintcache/delete", method = RequestMethod.POST)
   @ResponseBody
   public MensajeJSON deleteTaskInstanceCache(@RequestBody TaskInstanceCache taskincache) {
		logger.info("grabando el parametro....");
		Taskinstancecacheservice.delete(taskincache);
		return obtenerMensajeJSON(taskincache);		
   }
	/*
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////// TASKUSER SERVICE ////////////////////////////////////////////////////////////////////////////
	 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	 */

	@RequestMapping(value = "taskuser/findBandejaUsuario", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON listTaskUsersBandejaUsuarios(@RequestBody Long codigoJefe) {
		logger.info("listSecuences  " + codigoJefe.toString());

		return obtenerMensajeJSON(taskuserservice
				.findBandejaUsuario(codigoJefe));
	}

	@RequestMapping(value = "taskuser/list", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON listTaskUsers(@RequestBody FiltroDTO filtroDTO) {
		logger.info("listSecuences  " + filtroDTO.toString());

		return obtenerMensajeJSON(taskuserservice.findAll(filtroDTO));
	}

	@RequestMapping(value = "taskuser/save", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON saveTaskUser(@RequestBody TaskUser taskuser) {
		logger.info("grabando el parametro....");
		taskuserservice.save(taskuser);
		return obtenerMensajeJSON(taskuser);
	}

	@RequestMapping(value = "taskuser/update", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON updateTaskUser(@RequestBody TaskUser taskuser) {
		logger.info("grabando el parametro....");
		taskuserservice.update(taskuser);
		return obtenerMensajeJSON(taskuser);
	}

	@RequestMapping(value = "taskuser/delete", method = RequestMethod.POST)
	@ResponseBody
	public MensajeJSON deleteTaskUser(@RequestBody TaskUser taskuser) {
		logger.info("grabando el parametro....");
		taskuserservice.delete(taskuser);
		return obtenerMensajeJSON(taskuser);
	}

	
}
